home *** CD-ROM | disk | FTP | other *** search
/ MacHack 1996 / MacHack 1996.toast / Hacks / Hacks ’87 / Source ƒ.sit / Source ƒ / C ƒ / CITADEL BBS 'C' SRC / NETMISC.C < prev    next >
C/C++ Source or Header  |  1987-01-14  |  31KB  |  1,069 lines
  1. /************************************************************************/
  2. /*                netmisc.c                */
  3. /*                                    */
  4. /*    Networking functions of miscellaneous type.            */
  5. /************************************************************************/
  6.  
  7. /************************************************************************/
  8. /*                history                 */
  9. /*                                    */
  10. /* 86Aug20 HAW    History not maintained due to space problems.        */
  11. /************************************************************************/
  12.  
  13. #include "ctdl.h"
  14.  
  15. /************************************************************************/
  16. /*                contents                */
  17. /*                                    */
  18. /************************************************************************/
  19.  
  20. /************************************************************************/
  21. /*           External variable declarations in NET.C        */
  22. /************************************************************************/
  23. #ifdef NET_BUG
  24. FILE *localcheck;
  25. #endif
  26. FILE         *netLog, *netMisc;
  27. char         logNetResults = FALSE;
  28. ulong         roomHiMsgs[MAXROOMS];
  29. char         inNet = FALSE;
  30. unsigned char     sectBuf[SECTSIZE + 5];
  31. int         counter;
  32. int         callSlot;
  33. int         FinHour, FinMinute;
  34. label         normed, callerName, callerId;
  35.  
  36. int noKill, errCount = 0;
  37.  
  38. char         normId(), getNetMessage();
  39. char         callOut();
  40. unsigned char     inp();
  41.  
  42. static char *SupportedBauds[] = { "300", "300/1200", "300/1200/2400" };
  43. struct nodeRoomsTab *sharedRooms;
  44.  
  45. /************************************************************************/
  46. /*           External variable definitions for NET.C        */
  47. /************************************************************************/
  48. extern struct config    cfg;        /* Lots an lots of variables    */
  49. extern struct logBuffer logBuf;     /* Person buffer        */
  50. extern struct aRoom    roomBuf;    /* Room buffer            */
  51. extern struct rTable    roomTab[];
  52. extern struct msgB    msgBuf,tempMess;
  53. extern struct netBuffer netBuf;
  54. extern struct netTable    *netTab;
  55. extern FILE        *upfd;
  56. extern int        thisNet;
  57. extern char        onConsole;
  58. extern char        loggedIn;    /* Is we logged in?        */
  59. extern char        outFlag;    /* Output flag            */
  60. extern char        haveCarrier;    /* Do we still got carrier?    */
  61. extern unsigned char    modStat;    /* Needed so we don't die    */
  62. extern char        usingWCprotocol;/* WC flag            */
  63. extern char        WCError;
  64. extern int        thisRoom;
  65. extern int        thisLog;
  66. extern char        *dotdot;
  67. extern char        *confirm;
  68.  
  69. /************************************************************************/
  70. /*           External function definitions for NET.C        */
  71. /************************************************************************/
  72. FILE *safeopen();
  73. FILE *fopen();
  74. char *realloc();
  75. char *index();
  76. long getNumber();
  77.  
  78. /************************************************************************/
  79. /*    netSingleSend() Send a file via WC                */
  80. /************************************************************************/
  81. sendWCFile(fd)
  82. FILE *fd;
  83. {
  84.     int data;
  85.  
  86.     if (doWC(STARTUP)) {
  87.     while ((data = fgetc(fd)) != EOF && data != -1)
  88.         if (!sendWCChar(data)) break;
  89.     doWC(FINISH);
  90.     }
  91.     fclose(fd);
  92. }
  93.  
  94. /************************************************************************/
  95. /*    increment()                            */
  96. /************************************************************************/
  97. increment(c)
  98. unsigned char c;
  99. {
  100.     sectBuf[counter++] = c;
  101.     if (counter > SECTSIZE+2) {
  102.     interpret(cfg.pHangUp);
  103.     modStat = haveCarrier = FALSE;
  104.     }
  105.     return TRUE;
  106. }
  107.  
  108. /************************************************************************/
  109. /*    normId() Normalizes a node id.                    */
  110. /************************************************************************/
  111. char normId(source, dest)
  112. label source, dest;
  113. {
  114.     while (!isalpha(*source) && *source)
  115.     source++;
  116.     if (!*source) return FALSE;
  117.     *dest++ = toUpper(*source++);
  118.     while (!isalpha(*source) && *source)
  119.     source++;
  120.     if (!*source) return FALSE;
  121.     *dest++ = toUpper(*source++);
  122.     while (*source) {
  123.     if (isdigit(*source))
  124.         *dest++ = *source;
  125.     source++;
  126.     }
  127.     *dest = '\0';
  128.     return TRUE;
  129. }
  130.  
  131. /************************************************************************/
  132. /*    called_stabilize() Attempts to stabilize communication on    */
  133. /*               receiver end.                */
  134. /************************************************************************/
  135. called_stabilize()
  136. {
  137.     int  Time = 0, f, baudRunner = 0;
  138.     char noGood, notFinished, notDone = TRUE;
  139.     char laterMessage[100];
  140.  
  141.     pause(100);     /* Pause a full second */
  142.     while (notDone) {
  143.     noGood = TRUE;
  144.  
  145.     if (cfg.search_baud) {
  146.         while (MIReady())    inp();        /* Clear garbage    */
  147.         while (gotCarrier() && noGood && Time < 20) {
  148.         Time++;
  149.            for (notFinished = TRUE; noGood && gotCarrier() && notFinished;){
  150.             interpret(cfg.pBauds[baudRunner]);
  151.             noGood = check_for_init();
  152.             if (cfg.debug) splitF(netLog, ".\n");
  153.             notFinished = !(baudRunner == cfg.sysBaud);
  154.             baudRunner = (baudRunner + 1) % (cfg.sysBaud + 1);
  155.         }
  156.         }
  157.     }
  158.  
  159.     else {
  160.         interpret(cfg.pBauds[interpret(cfg.pCheckBaud)]);
  161.  
  162.         for (; gotCarrier() && Time < 20 && noGood; Time++) {
  163.         noGood = check_for_init();
  164.         if (cfg.debug) splitF(netLog, ".\n");
  165.         }
  166.         if (cfg.debug) splitF(netLog, "\n");
  167.     }
  168.  
  169.     if (!gotCarrier()) {
  170.         modStat = haveCarrier = FALSE;
  171.         splitF(netLog, "Lost carrier\n");
  172.         return FALSE;
  173.     }
  174.  
  175.     if (noGood && Time == 20) {
  176.         outFlag = IMPERVIOUS;
  177.         sPrintf(laterMessage,
  178.  "System will be in network mode for another %d minutes; please call back.\n",
  179.                         timeLeft());
  180.         if (cfg.search_baud) {
  181.         for (baudRunner = cfg.sysBaud; baudRunner > -1; baudRunner--) {
  182.             interpret(cfg.pBauds[baudRunner]);
  183.             mPrintf(laterMessage);
  184.         }
  185.         }
  186.         else
  187.         mPrintf(laterMessage);
  188.         interpret(cfg.pHangUp);
  189.         notDone = modStat = haveCarrier = FALSE;
  190.         outFlag = OUTOK;
  191.     }
  192.     else {
  193. if (cfg.debug) splitF(netLog, "&");
  194.         outMod(~7 );
  195.         outMod(~13);
  196.         outMod(~69);
  197.         f = receive(2);
  198.         if (f == ACK)
  199.         return TRUE ;
  200.         else if (cfg.debug) splitF(netLog, "%d ", f);
  201.  
  202.         if (!gotCarrier())
  203.         modStat = haveCarrier = notDone = FALSE;
  204.     }
  205.     }
  206.     if (!gotCarrier())
  207.     modStat = haveCarrier = FALSE;
  208.     return FALSE;
  209. }
  210.  
  211. /************************************************************************/
  212. /*    check_for_init() Looks for networking initialization sequence    */
  213. /************************************************************************/
  214. check_for_init()
  215. {
  216.     int       count, timeOut;
  217.     unsigned char thisVal, lastVal;
  218.  
  219.     lastVal = 0;
  220.     timeOut = (INTERVALS / 2) * (500);
  221.     for (count = 0; count < timeOut; count++) {
  222.     if (MIReady()) {
  223.         thisVal = inp();
  224. if (cfg.debug) splitF(netLog, "%d ", thisVal);
  225.         switch (thisVal) {
  226.         case 7:  lastVal = 7; break;
  227.         case 13:
  228.              if (lastVal == 7) lastVal = 13;
  229.              else           lastVal = 0;
  230.              break;
  231.         case 69:
  232.              if (lastVal == 13) return FALSE;
  233.              else           lastVal = 0;
  234.              break;
  235.         default:
  236.              lastVal = 0;
  237.         }
  238.     }
  239.     else shortPause();
  240.     }
  241.     return TRUE;
  242. }
  243.  
  244. /************************************************************************/
  245. /*    searchNet() Searches net for the given Id.            */
  246. /************************************************************************/
  247. searchNet(forId)
  248. char *forId;
  249. {
  250.     int rover;
  251.     label temp;
  252.  
  253.     for (rover = 0; rover < cfg.netSize; rover++) {
  254.     if (netTab[rover].ntflags.in_use &&
  255.         hash(forId) == netTab[rover].ntidhash) {
  256.         getNet(rover);
  257.         normId(netBuf.netId, temp);
  258.         if (strCmpU(temp, forId) == SAMESTRING)
  259.         return rover;
  260.     }
  261.     }
  262.     return ERROR;
  263. }
  264.  
  265. /************************************************************************/
  266. /*    readMail() Integrates mail into the data base            */
  267. /************************************************************************/
  268. readMail(zap, procFn)
  269. char zap;
  270. int (*procFn)();
  271. {
  272.     label tempNm;
  273.  
  274.     strCpy(tempNm, "a:tempmail.$$$");
  275.     tempNm[0] = cfg.netDisk + 'a';
  276.     if ((netMisc = safeopen(tempNm, "rb")) == NULL) {
  277.     no_good("Couldn't open tempmail file from %s.", TRUE);
  278.     return;
  279.     }
  280.     getRoom(MAILROOM);
  281.     noKill = FALSE;
  282.     while (getNetMessage()) {
  283.     if (strCmpU(cfg.nodeId + cfg.codeBuf, tempMess.mborig) != SAMESTRING)
  284. /*        inMail(); */
  285.         (*procFn)();
  286.     }
  287.     fclose(netMisc);
  288.     if (zap && !noKill) unlink(tempNm);
  289.     else if (zap) {
  290.     sPrintf(msgBuf.mbtext, "%c:temp%d.$$$", cfg.netDisk + 'a', errCount++);
  291.     rename(tempNm, msgBuf.mbtext);
  292.     }
  293. }
  294.  
  295. /************************************************************************/
  296. /*    getNetMessage() gets a message from a global file        */
  297. /************************************************************************/
  298. char getNetMessage()
  299. {
  300.     int marker, c;
  301.  
  302.     zero_struct(tempMess);
  303.     marker = 0;
  304.     while (marker != 'M') {
  305.     while ((marker = getc(netMisc)) != -1 && marker == ' ')
  306.         ;
  307.     if (marker == -1) {
  308.         return FALSE;
  309.     }
  310.     switch (marker) {
  311.         case 'A':
  312.         getNetStr(tempMess.mbauth);
  313.         break;
  314.         case 'D':
  315.         getNetStr(tempMess.mbdate);
  316.         break;
  317.         case 'N':
  318.         getNetStr(tempMess.mboname);
  319.         break;
  320.         case 'O':
  321.         getNetStr(tempMess.mborig);
  322.         break;
  323.         case 'R':
  324.         getNetStr(tempMess.mbroom);
  325.         break;
  326.         case 'S':
  327.         getNetStr(tempMess.mbsrcId);
  328.         break;
  329.         case 'T':
  330.         getNetStr(tempMess.mbto);
  331.         break;
  332.         case 'C':
  333.         getNetStr(tempMess.mbtime);
  334.         break;
  335.         default:
  336.         if (marker != 'M')
  337.             while ((c = getc(netMisc)) != -1 && c != '\0')
  338.             ;
  339.             break;
  340.     }
  341.     }
  342.     getNetStr(tempMess.mbtext);
  343.     return TRUE;
  344. }
  345.  
  346. /************************************************************************/
  347. /*    getNetStr() gets a string from networked message        */
  348. /************************************************************************/
  349. getNetStr(place)
  350. char *place;
  351. {
  352.     int i, c;
  353.  
  354.     i = 0;
  355.     do    {
  356.     c = getc(netMisc);
  357.     if (c == '\r') c = '\n';
  358.     place[i++] = c;
  359.     } while (c != -1 && c != '\0');
  360. }
  361.  
  362. /************************************************************************/
  363. /*    inMail() integrates mail into database                */
  364. /************************************************************************/
  365. inMail()
  366. {
  367.     int          logNo;
  368.     struct logBuffer lBuf;
  369.  
  370.     if (!tempMess.mbto[0]) {
  371.     splitF(netLog, "'to' error\n");
  372.     noKill = TRUE;
  373.     return ;
  374.     }
  375.     logNo = findPerson(tempMess.mbto, &lBuf);
  376.     strCpy(msgBuf.mbto, tempMess.mbto);
  377.     if (logNo == ERROR && hash(tempMess.mbto) != hash("Sysop")) {
  378.     splitF(netLog, "Mail to '%s' cannot be delivered.\n", tempMess.mbto);
  379.     return;
  380.     }
  381.     else splitF(netLog, "Delivering mail to '%s'\n", tempMess.mbto);
  382.     if (strCmpU(tempMess.mbto, "sysop") != 0)
  383.     strCpy(tempMess.mbto, lBuf.lbname);
  384.     putNetMessage();
  385.     noteMessage(&lBuf, logNo);
  386. }
  387.  
  388. /************************************************************************/
  389. /*    netController() Handles the net stuff                */
  390. /************************************************************************/
  391. netController()
  392. {
  393.     int x;
  394.     int searcher = 0, start, first;
  395.     label name;
  396.     ulong waitTime, count;
  397.     int yr, hr, min, dy;
  398.     char *mn;
  399.  
  400.     getdate(&yr, &mn, &dy, &hr, &min);
  401.  
  402.     if (logNetResults) {
  403.     sPrintf(name, "%c:netlog.sys", cfg.homeDisk + 'a');
  404.     netLog = fopen(name, "a");
  405.     }
  406.     else
  407.     netLog = NULL;
  408.  
  409.     inNet = TRUE;
  410.     loggedIn = FALSE;            /* Let's be VERY sure.        */
  411.     thisLog = -1;
  412. splitF(netLog, "\n---------------In Networking Mode--------------\n%d%s%02d\n",
  413.                     yr, mn, dy);
  414.     modStat = haveCarrier = FALSE;
  415.     setTime();
  416.     initNetRooms();
  417.  
  418.     while ((x = timeLeft()) > 0) {    /* "Can we say inefficient?"    */
  419.     waitTime = (cfg.catChar % 5) + 1;
  420.     while (waitTime > minimum(5, ((x/2)))) waitTime /= 2;
  421.     /*    for (count = 0; count < waitTime * 6000; count++) {    */
  422.     for (count = 0; count < waitTime * 6000 && !KBReady(); count++) {
  423.         pause(1);
  424.         if (gotCarrier()) break;
  425.     }
  426. if(KBReady()) getCh();
  427.     if (gotCarrier()) {
  428.         modStat = haveCarrier = TRUE;
  429.         called();
  430.     }
  431.     if (cfg.netSize != 0) {
  432.         start = searcher;
  433.         do {
  434.         if (needToCall(searcher)) {
  435.             if (callOut(searcher))
  436.             caller();
  437.             for (count = 0; count < 20 && !gotCarrier(); count++)
  438.                /* Give the modem a chance to recover   */
  439.             pause(50);
  440.             if (gotCarrier()) {
  441.             modStat = haveCarrier = TRUE;
  442.             called();
  443.             }
  444.         }
  445.         searcher = (searcher + 1) % cfg.netSize;
  446.         } while ((searcher+1) % cfg.netSize != start);
  447.     }
  448.     }
  449. splitF(netLog, "\n---------------Out of Networking Mode--------------\n\n\n");
  450.     for (searcher = 0; searcher < cfg.netSize; searcher++)
  451.     if (needToCall(searcher)) break;
  452.     if (searcher < cfg.netSize) {
  453.     sPrintf(msgBuf.mbtext, "The following systems could not be reached: ");
  454.     for (searcher = 0, first = 1; searcher < cfg.netSize; searcher++)
  455.         if (needToCall(searcher)) {
  456.         if (!first) strCat(msgBuf.mbtext,", ");
  457.         first = FALSE;
  458.         getNet(searcher);
  459.         strCat(msgBuf.mbtext, netBuf.netName);
  460.         }
  461.     strCat(msgBuf.mbtext, ".");
  462.     aideMessage(FALSE);
  463.     }
  464.     free(sharedRooms);
  465.     setSharedRooms();
  466.     interpret(cfg.pInitPort);
  467.     modStat = haveCarrier = FALSE;
  468.     inNet = FALSE;
  469.     if (logNetResults) {
  470.     fclose(netLog);
  471.     }
  472. }
  473.  
  474. /************************************************************************/
  475. /*    initNetRooms() Initializes buncha flags 'n things.  Kludgey.    */
  476. /************************************************************************/
  477. initNetRooms()
  478. {
  479.     int rover, i;
  480.  
  481.     for (rover = 0; rover < cfg.netSize; rover++) {
  482.     getNet(rover);
  483.     if (netBuf.nbflags.in_use) {
  484.         for (i = 0; i < SHARED_ROOMS; i++) {
  485.         resetNeedsProcessing(i);
  486.         }
  487.         putNet(rover);
  488.     }
  489.     }
  490. }
  491.  
  492. /************************************************************************/
  493. /*    setTime() Sets up some global variables for the networker    */
  494. /************************************************************************/
  495. setTime()
  496. {
  497.     int yr, hr, min, dy;
  498.     char *mn;
  499.  
  500.     getdate(&yr, &mn, &dy, &hr, &min);
  501.     FinHour   = hr + cfg.netLength / 60;
  502.     FinMinute = cfg.netLength % 60;
  503. }
  504.  
  505. /************************************************************************/
  506. /*    timeLeft() Does a rough estimate of how much time left        */
  507. /************************************************************************/
  508. int timeLeft()
  509. {
  510.     int yr, hr, min, dy;
  511.     char *mn;
  512.  
  513.     getdate(&yr, &mn, &dy, &hr, &min);
  514.     if (hr == FinHour && min > FinMinute) return -1;
  515.     if (hr > FinHour) return -1;
  516.     return ((FinHour - hr) * 60 + abs(min - FinMinute));
  517. }
  518.  
  519. /************************************************************************/
  520. /*    callOut() Attempts to call some other system.            */
  521. /************************************************************************/
  522. char callOut(i)
  523. int i;
  524. {
  525.     char  call[80];
  526.     label blip1;
  527.  
  528.     getNet(callSlot = i);
  529.     strCpy(normed, netBuf.netId);        /* Cosmetics */
  530.     strCpy(callerId, netBuf.netId);
  531.     strCpy(callerName, netBuf.netName);
  532.     splitF(netLog, "Calling %s @ %s: ", netBuf.netName, netBuf.netId);
  533.     interpret(cfg.pBauds[minimum(netBuf.baudCode, cfg.sysBaud)]);
  534.     normId(netBuf.netId, blip1);
  535.     strCpy(call, cfg.codeBuf + cfg.netPrefix);
  536.     if (!netBuf.nbflags.local) {
  537.     if (!cfg.longHaul)
  538.         crashout("Supposed to call long distance when LONG-HAUL is 0?");
  539.     strCat(call, "1");
  540.     strCat(call, blip1 + 2);
  541.     }
  542.     else {
  543.     strCat(call, blip1 + 5);
  544.     }
  545.     strCat(call, cfg.codeBuf + cfg.netSuffix);
  546.     moPuts(call);
  547.     for (i = 0; i < 4000; i++) {
  548.     pause(1);
  549.     if (gotCarrier()) break;
  550.     }
  551.     if (gotCarrier())
  552.     return modStat = haveCarrier = TRUE;
  553.  
  554.     outMod('\r');          /* Take SmartModem out of call mode    */
  555.     splitF(netLog, "No luck.\n");
  556.     return FALSE;
  557. }
  558.  
  559. /************************************************************************/
  560. /*    moPuts() Put a string out to modem without carr check        */
  561. /************************************************************************/
  562. moPuts(s)
  563. char *s;
  564. {
  565.     while (*s) {
  566.     pause(5);
  567.     if (cfg.debug) putchar(*s);
  568.     outMod(*s++);
  569.     }
  570. }
  571.  
  572. /************************************************************************/
  573. /*    netMessage() Send message via net                */
  574. /************************************************************************/
  575. netMessage(uploading)
  576. char uploading;
  577. {
  578.     extern char *ALL_LOCALS;
  579.     extern char *R_SH_MARK;
  580.     char  notDone = TRUE;
  581.     label sys;
  582.     char  *address;
  583.  
  584.     if (!cfg.netParticipant) {
  585.     mPrintf("This Citadel is not participating in the net.\n ");
  586.     return;
  587.     }
  588.  
  589.     zero_struct(msgBuf);
  590.  
  591.     if (!loggedIn || !logBuf.lbflags.NET_PRIVS) {
  592.     mPrintf("Sorry, you don't have net privileges.\n ");
  593.     return;
  594.     }
  595.  
  596.     if (thisRoom == MAILROOM) {
  597.     do {
  598.         getString("system to send to", sys, 20, TRUE, ECHO);
  599.         if (strLen(sys) == 0) return;
  600.         if (sys[0] == '?')
  601.         writeNet(FALSE);
  602.         else {
  603.            if (searchNameNet(sys) == ERROR && strCmpU(sys, ALL_LOCALS) != 0)
  604.             mPrintf("No such system currently part of the net\n ");
  605.         else
  606.             notDone = FALSE;
  607.         }
  608.     } while (notDone);
  609.  
  610.     if (strCmpU(sys, ALL_LOCALS) != 0) {
  611.         getNet(searchNameNet(sys));
  612.         if (!cfg.longHaul && !netBuf.nbflags.local) {
  613.         mPrintf("Sorry, local Citadels only, please.\n ");
  614.         return;
  615.         }
  616.         if (!netBuf.nbflags.local && logBuf.credit == 0) {
  617.         mPrintf("Sorry, you have no credit for long distance net.\n ");
  618.         return;
  619.         }
  620.         address = netBuf.netName;
  621.     }
  622.     else {
  623.         if (!logBuf.lbflags.AIDE) {
  624.         mPrintf("Sorry, you don't have announcement privileges.\n ");
  625.         return;
  626.         }
  627.         address = ALL_LOCALS;
  628.     }
  629.     }
  630.     else {
  631.     if (!roomBuf.rbflags.SHARED) {
  632.         mPrintf("This is not a network room\n ");
  633.         return;
  634.     }
  635.     address = R_SH_MARK;
  636.     strCpy(msgBuf.mboname, cfg.codeBuf + cfg.nodeName);
  637.     }
  638.     strCpy(msgBuf.mbaddr, address);
  639.     procMessage(uploading);
  640. }
  641.  
  642. /************************************************************************/
  643. /*    writeNet() write up nodes on the net.                */
  644. /************************************************************************/
  645. writeNet(idsAlso)
  646. char idsAlso;
  647. {
  648.     int  rover;
  649.  
  650.     outFlag = OUTOK;
  651.     mPrintf("Systems on the net:\n ");
  652.     for (rover = 0; rover < cfg.netSize; rover++) {
  653.     getNet(rover);
  654.     if (netBuf.nbflags.in_use) {
  655.         mPrintf("%-22s", netBuf.netName);
  656.         if (idsAlso) mPrintf("%-22s%-16s%s", netBuf.netId,
  657.             (needToCall(rover)) ? "<need to call>" : "",
  658.             SupportedBauds[netBuf.baudCode]);
  659.         mPrintf("\n ");
  660.     }
  661.     }
  662.     if (!idsAlso) mPrintf("'&L' == Local Systems Announcement\n ");
  663. }
  664.  
  665. /************************************************************************/
  666. /*    searchNameNet() Search net for given node name            */
  667. /************************************************************************/
  668. searchNameNet(name)
  669. label name;
  670. {
  671.     int rover;
  672.  
  673.     for (rover = 0; rover < cfg.netSize; rover++) {
  674.     if (netTab[rover].ntflags.in_use &&
  675.         hash(name) == netTab[rover].ntnmhash) {
  676.         getNet(rover);
  677.         if (strCmpU(netBuf.netName, name) == SAMESTRING)
  678.         return rover;
  679.     }
  680.     }
  681.     return ERROR;
  682. }
  683.  
  684. /************************************************************************/
  685. /*    netStuff() Handles networking for the sysop            */
  686. /************************************************************************/
  687. netStuff()
  688. {
  689.     extern char      *who_str;
  690.     label         who;
  691.     struct logBuffer lBuf;
  692.     int          logNo;
  693.  
  694.     do {
  695.     outFlag = OUTOK;
  696.     mPrintf("\n Net function: ");
  697.     switch (toUpper(iChar())) {
  698.         case 'R':
  699.         mPrintf("equest File\n ");
  700.         fileRequest();
  701.         break;
  702.         case 'X':
  703.         mPrintf("\bExit to main menu");
  704.         return;
  705.         case 'C':
  706.         mPrintf("redit setting\n ");
  707.         getNormStr(who_str, who, NAMESIZE, ECHO);
  708.         logNo    = findPerson(who, &lBuf);
  709.         if (logNo == ERROR)   {
  710.             mPrintf("No such person\n ");
  711.             break;
  712.         }
  713.         mPrintf("%s currently has %d credits.", who, lBuf.credit);
  714.         lBuf.credit = (int) getNumber("How many now", 0l, 255l);
  715.         if (loggedIn  &&  strCmpU(logBuf.lbname, who) == SAMESTRING)
  716.             logBuf.credit = lBuf.credit;
  717.  
  718.         putLog(&lBuf, logNo);
  719.  
  720.         break;
  721.         case 'V':
  722.         mPrintf("iew net list\n ");
  723.         writeNet(TRUE);
  724.         break;
  725.         case 'A':
  726.         mPrintf("dd node to net\n ");
  727.         addNetNode();
  728.         break;
  729.         case 'E':
  730.         mPrintf("dit a node\n ");
  731.         editNode();
  732.         break;
  733.         case 'N':
  734.         mPrintf("et privilege toggle\n ");
  735.         getNormStr(who_str, who, NAMESIZE, ECHO);
  736.         logNo    = findPerson(who, &lBuf);
  737.         if (logNo == ERROR)   {
  738.             mPrintf("No such person\n ");
  739.             break;
  740.         }
  741.         mPrintf(
  742.             "%s has %snet privileges\n ",
  743.             who,
  744.             (lBuf.lbflags.NET_PRIVS) ? "no " : ""
  745.         );
  746.         if (!getYesNo(confirm))   break;
  747.         lBuf.lbflags.NET_PRIVS = !lBuf.lbflags.NET_PRIVS;
  748.         if (strCmpU(lBuf.lbname, logBuf.lbname) == SAMESTRING)
  749.             logBuf.lbflags.NET_PRIVS = lBuf.lbflags.NET_PRIVS;
  750.  
  751.         putLog(&lBuf, logNo);
  752.  
  753.         break;
  754.         case '?':
  755.         tutorial("netopt.mnu");
  756.         break;
  757.         default:
  758.         mPrintf(" ?\n ");
  759.     }
  760.     } while (onLine());
  761. }
  762.  
  763. /************************************************************************/
  764. /*    addNetNode() Add a node to the net listing            */
  765. /************************************************************************/
  766. addNetNode()
  767. {
  768.     int searcher, i;
  769.     char  goodAnswer;
  770.     label temp;
  771.  
  772.     zero_struct(netBuf);        /* Useful initialization       */
  773.     do {
  774.     getNormStr("System name", netBuf.netName, NAMESIZE, ECHO);
  775.     if (strLen(netBuf.netName) == 0) return;
  776.     if ((goodAnswer = strCmpU(ALL_LOCALS, netBuf.netName)) == 0)
  777.         mPrintf("Sorry, reserved name\n ");
  778.     } while (!goodAnswer);
  779.     getString("System ID", netBuf.netId, NAMESIZE, FALSE, ECHO);
  780.     if (strLen(netBuf.netId) == 0) return;
  781.     netBuf.baudCode = (int) getNumber(
  782.             "Baud code (0=300, 1=300/1200, 2=300/1200/2400)", 0l, 2l);
  783.     netBuf.nbflags.local       = getYesNo("Is system local");
  784.     netBuf.nbflags.in_use      = TRUE;
  785.  
  786.     for (searcher = 0; searcher < cfg.netSize; searcher++)
  787.     if (netTab[searcher].ntflags.in_use == FALSE) break;
  788.  
  789.     if (searcher != cfg.netSize)
  790.     putNet(searcher);
  791.     else {
  792.     netTab =
  793.     (struct netTable *) realloc(netTab, sizeof (*netTab) * ++cfg.netSize);
  794.     sharedRooms =
  795.     (struct nodeRoomsTab *) realloc(sharedRooms, sizeof (*sharedRooms) *
  796.                                  cfg.netSize);
  797.     searcher = cfg.netSize - 1;
  798.     putNet(searcher);
  799.     }
  800.     normId(netBuf.netId, temp);
  801.     netTab[searcher].ntnmhash = hash(netBuf.netName);
  802.     netTab[searcher].ntidhash = hash(temp);
  803.     zero_struct(sharedRooms[searcher].rooms);
  804. }
  805.  
  806. /************************************************************************/
  807. /*    editNode() Edit a net node                    */
  808. /************************************************************************/
  809. editNode()
  810. {
  811.     label sysname, temp;
  812.     int   place;
  813.  
  814.     getNormStr("Name of system to edit", sysname, NAMESIZE, ECHO);
  815.     if ((place = searchNameNet(sysname)) == ERROR) {
  816.     mPrintf("%s not listed!\n ", sysname);
  817.     return;
  818.     }
  819.     getNet(place);
  820.     mPrintf("\n Node %s:\n Id: %s", netBuf.netName, netBuf.netId);
  821.     mPrintf("\n System is a %slocal system, ",
  822.                  (netBuf.nbflags.local) ? "" : "non-");
  823.     mPrintf("and the baud setting is for %s.\n ",
  824.             SupportedBauds[netBuf.baudCode]);
  825.     mPrintf("There is %soutgoing mail, ",
  826.               (netBuf.nbflags.normal_mail) ? "" : "no ");
  827.     mPrintf("and there are %sfile requests outstanding.\n ",
  828.             (netBuf.nbflags.room_files) ? "" : "no ");
  829.     while (1) {
  830.     outFlag = OUTOK;
  831.     mPrintf("\n (%s) edit fn: ", netBuf.netName);
  832.     switch (toUpper(iChar())) {
  833.         case 'Z': dumpNodeRoom(FALSE);
  834.             break;
  835.         case 'X':
  836.         mPrintf("\bExit to net menu");
  837.         normId(netBuf.netId, temp);
  838.         netTab[place].ntnmhash = hash(netBuf.netName);
  839.         netTab[place].ntidhash = hash(temp);
  840.         netTab[place].ntflags.in_use = netBuf.nbflags.in_use;
  841.         putNet(place);
  842.         return;
  843.         case 'B':
  844.         mPrintf("aud code change\n ");
  845.         netBuf.baudCode = (int) getNumber(
  846.              "Baud code (0=300, 1=300/1200, 2=300/1200/2400)", 0l, 2l);
  847.         break;
  848.         case 'N':
  849.         mPrintf("ame change\n ");
  850.         getNormStr("System name", temp, NAMESIZE, ECHO);
  851.         if (strLen(temp) != 0) strCpy(netBuf.netName);
  852.         break;
  853.         case 'I':
  854.         mPrintf("D change\n ");
  855.         getString("System ID", temp, NAMESIZE, FALSE, ECHO);
  856.         if (strLen(temp) != 0) strCpy(netBuf.netId);
  857.         break;
  858.         case 'K':
  859.         mPrintf("ill node from list\n ");
  860.         if (netBuf.nbflags.normal_mail)
  861.             mPrintf("There is outgoing mail outstanding.\n ");
  862.         if (netBuf.nbflags.room_files)
  863.             mPrintf("There are file requests outstanding.\n ");
  864.         if (getYesNo("Confirm")) {
  865.             netBuf.nbflags.in_use = FALSE;
  866.             putNet(place);
  867.             sPrintf(temp, "a:%d.ml", thisNet);
  868.             temp[0] = cfg.netDisk + 'a';
  869.             unlink(temp);
  870.             sPrintf(temp, "a:%d.rfl", thisNet);
  871.             temp[0] = cfg.netDisk + 'a';
  872.             unlink(temp);
  873.             return;
  874.         }
  875.         break;
  876.         case 'L':
  877.         mPrintf("ocal setting\n ");
  878.         netBuf.nbflags.local = getYesNo("Is system local");
  879.         break;
  880.         case '?':
  881.         tutorial("netedit.mnu");
  882.         break;
  883.         default:
  884.         mPrintf("?\n ");
  885.     }
  886.     }
  887. }
  888.  
  889. /************************************************************************/
  890. /*    inNetTime() Time to network?                    */
  891. /************************************************************************/
  892. inNetTime(hr, mn)
  893. int hr, mn;
  894. {
  895.     int thisHour, thisMin;
  896.  
  897.     thisHour = cfg.netHour + (cfg.netLength / 60);
  898.     thisMin  = cfg.netLength - ((thisHour - cfg.netHour) * 60);
  899.     if (hr < cfg.netHour) return FALSE;
  900.     if (hr > thisHour)      return FALSE;
  901.     if (mn >= thisMin)      return FALSE;
  902.     return TRUE;
  903. }
  904.  
  905. /************************************************************************/
  906. /*    fileRequest() For network requests of files.            */
  907. /************************************************************************/
  908. fileRequest()
  909. {
  910.     struct fl_req file_data;
  911.     label system, dr, data;
  912.     char   loc[100];
  913.     char  abort, goodname;
  914.     FILE  *temp;
  915.     char  *cd, *gcdir();
  916.     int   place;
  917.     char  ambiguous;
  918.  
  919.     getNormStr("system to request file from", system, NAMESIZE, ECHO);
  920.     if (strLen(system) == 0) return;
  921.     if ((place = searchNameNet(system)) == ERROR) {
  922.     mPrintf("%s not listed!\n ", system);
  923.     return;
  924.     }
  925.     getNet(place);
  926.     sPrintf(loc, "name of room on %s that has desired file", system);
  927.     getNormStr(loc, file_data.room, NAMESIZE, ECHO);
  928.     if (strLen(file_data.room) == 0) return;
  929.     getNormStr("the file(s)'s name", file_data.roomfile, NAMESIZE, ECHO);
  930.     if (strLen(file_data.roomfile) == 0) return;
  931.     ambiguous = !(index(file_data.roomfile, '*') == NULL &&
  932.           index(file_data.roomfile, '?') == NULL);
  933.     getString("what drive you want the file put on", dr, 2, FALSE, ECHO);
  934.     if (strLen(dr) == 0) return;
  935.     file_data.drive = dr[0];
  936.     mPrintf("Now we want to specify the exact directory on drive ");
  937.     mPrintf("%c to place the file in. ", toUpper(dr[0]));
  938.     mPrintf("Type the exact path, from the root.");
  939.     mPrintf(" If you want it in the root directory, then just type ");
  940.     mPrintf("Return. There is some error checking here, but not much.");
  941.     mPrintf(" '?' will abort.");
  942.     abort = FALSE;
  943.     setSpace(toUpper(dr[0]) - 'A', "");
  944.     cd = gcdir("");
  945.     good_path(file_data.path, 98);
  946.     if (file_data.path[1] != '?') {
  947.     if (!ambiguous) {
  948.         chdir(file_data.path);
  949.         do {
  950.         getString("name the file will be stored under on this system",
  951.                      file_data.filename, NAMESIZE, FALSE, ECHO);
  952.         if (strLen(file_data.filename) == 0) abort = TRUE;
  953.         else {
  954.             temp = safeopen(file_data.filename, "r");
  955.             if (temp != NULL) {
  956.             fclose(temp);
  957.                mPrintf("'%s' already exists, and ", file_data.filename);
  958.             mPrintf("will be overwritten during networking.");
  959.             goodname = getYesNo("Is this what you want");
  960.             }
  961.             else goodname = TRUE;
  962.         }
  963.         } while (!abort && !goodname);
  964.     }
  965.     else {
  966.         mPrintf("Ambiguous requests may result in overwriting.\n ");
  967.         file_data.filename[0] = 0;
  968.     }
  969.     }
  970.     else abort = TRUE;
  971.  
  972.     chdir(cd);
  973.     free(cd);
  974.     setSpace(cfg.homeDisk, "");
  975.     if (!abort) {
  976.     sPrintf(data, "a:%d.rfl", place);
  977.     data[0] = cfg.netDisk + 'a';
  978.     temp = safeopen(data, "ab");
  979.     if (temp == NULL) {
  980.         mPrintf("Couldn't append to '%s'????", data);
  981.     }
  982.     fwrite(&file_data, sizeof (file_data), 1, temp);
  983.     fclose(temp);
  984.     netBuf.nbflags.room_files = TRUE;
  985.     putNet(place);
  986.     }
  987. }
  988.  
  989. /************************************************************************/
  990. /*    roomsShared() Returns true if this system has a room with new    */
  991. /*              data to share (orSomething)            */
  992. /************************************************************************/
  993. roomsShared(slot)
  994. int slot;
  995. {
  996.     int i;
  997.  
  998.     for (i = 0; i < SHARED_ROOMS; i++) {
  999.     if (isSharedFlag(slot, i)) {
  1000.         if (roomHiMsgs[netTabRoomSlot(slot, i)] >
  1001.                       sharedRooms[slot].rooms[i].lastMess)
  1002.         return TRUE;
  1003.     }
  1004.     }
  1005.  
  1006.     return FALSE;
  1007. }
  1008.  
  1009. /************************************************************************/
  1010. /*    setSharedRooms() Initializes the roomHiMsgs[] array        */
  1011. /************************************************************************/
  1012. setSharedRooms()
  1013. {
  1014.     ulong findHighestNative();
  1015.     char *malloc();
  1016.     int rover, i;
  1017.  
  1018.     sharedRooms = (struct nodeRoomsTab *) malloc(sizeof (*sharedRooms) *
  1019.                                  cfg.netSize);
  1020.     for (rover = 0; rover < MAXROOMS; rover++) {
  1021.     if (roomTab[rover].rtflags.SHARED)
  1022.         roomHiMsgs[rover] = findHighestNative(rover);
  1023.     else
  1024.         roomHiMsgs[rover] = 0l;
  1025.     }
  1026.     for (rover = 0; rover < cfg.netSize; rover++) {
  1027.     getNet(rover);
  1028.     if (netBuf.nbflags.in_use) {
  1029.         copy_array(netBuf.netRooms, sharedRooms[rover].rooms);
  1030.     }
  1031.     }
  1032. }
  1033.  
  1034. dumpNodeRoom(file)
  1035. char file;
  1036. {
  1037. #ifdef NET_BUG
  1038.     label name;
  1039.     int rover;
  1040.  
  1041.     if (!inNet) {
  1042.     if (logNetResults && file) {
  1043.         sPrintf(name, "%c:netlog.sys", cfg.homeDisk + 'a');
  1044.         netLog = fopen(name, "a");
  1045.     }
  1046.     else
  1047.         netLog = NULL;
  1048.     }
  1049.  
  1050.     splitF(netLog, "-- DEBUG: dump of node %s (#%d) --\n", netBuf.netName,
  1051.                                thisNet);
  1052.     splitF(netLog, "Room list dump:\n");
  1053.     for (rover = 0; rover < SHARED_ROOMS; rover++) {
  1054.     splitF(netLog, "Slot %d: room#0x%-9xgen=0x%x", rover,
  1055.         netBuf.netRooms[rover].srslot,
  1056.         netBuf.netRooms[rover].srgen);
  1057.     if (netBuf.netRooms[rover].srgen & 0x8000) {
  1058.         splitF(netLog, " IN USE apparently\n");
  1059.         splitF(netLog, "%9croom is %s, gen is 0x%x\n", ' ',
  1060.             roomTab[netRoomSlot(rover)].rtname,
  1061.             roomTab[netRoomSlot(rover)].rtgen);
  1062.     }
  1063.     else splitF(netLog, "\n");
  1064.     }
  1065.     if (!inNet && logNetResults && file)
  1066.     fclose(netLog);
  1067. #endif
  1068. }
  1069.